Unsupervised Learning_R5_Project2¶
Classify a given silhouette as one of three different types of vehicle¶
Import Python Libraries¶
In [1]:
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
%matplotlib inline
plt.rc("font", size=10)
import seaborn as sns
sns.set(style="white")
sns.set(style="darkgrid", color_codes=True)
from scipy.stats import zscore
from sklearn.preprocessing import LabelEncoder, StandardScaler
from sklearn.model_selection import train_test_split, GridSearchCV
from sklearn.decomposition import PCA
from sklearn.svm import SVC
from sklearn.metrics import accuracy_score,confusion_matrix, precision_score, recall_score, f1_score
from sklearn.metrics import roc_auc_score, roc_curve, classification_report
About the Data:¶
Classify a given silhouette of vehicles.
The purpose of the case study is to classify a given silhouette as one of three different types of vehicle, using a set of features extracted from the silhouette. The vehicle may be viewed from one of many different angles. Four "Corgie" model vehicles were used for the experiment: a double-decker bus, Chevrolet van, Saab 9000 and an Opel Manta 400 cars. This particular combination of vehicles was chosen with the expectation that the bus, van and either one of the cars would be readily distinguishable, but it would be more difficult to distinguish between the cars..
Load Data and read the data as a data frame¶
In [2]:
vehicle_df = pd.read_csv("vehicle.csv")
Shape of the data¶
In [3]:
vehicle_df.shape
Out[3]:
Data type of each attribute¶
In [4]:
vehicle_df.dtypes
Out[4]:
Check that data is read correctly using head, tail and sample¶
In [5]:
vehicle_df.head(5)
Out[5]:
In [6]:
vehicle_df.tail(5)
Out[6]:
In [7]:
vehicle_df.sample(5)
Out[7]:
Info on column name, count of records, not-null/null, datatype, count of datatypes and memory usage of columns¶
In [8]:
vehicle_df.info()
Input variables¶
In [9]:
print(vehicle_df.drop('class', axis=1).dtypes)
Target variable¶
In [10]:
print("class : values are {}, dtype is {}".format(vehicle_df['class'].unique(),
vehicle_df['class'].dtype))
Description of The Target Variables¶
- class Silhouette of three types of vehicles 'van', 'car' and 'bus'
Null Values¶
In [11]:
vehicle_df.isna().sum()
Out[11]:
Replacing null values in the columns with mean of the column¶
In [12]:
for col in vehicle_df.drop('class', axis=1) :
if(vehicle_df[col].isna().sum() != 0) :
vehicle_df[col].fillna(round(vehicle_df[col].mean()), inplace = True)
In [13]:
vehicle_df.isna().sum()
Out[13]:
Negative values¶
In [14]:
(vehicle_df.drop('class', axis=1) < 0).sum()
Out[14]:
In [15]:
print("\nThere are no Negative values in the dataset\n")
Duplicated data¶
In [16]:
vehicle_df.duplicated().sum()
Out[16]:
In [17]:
print("\nThere are no duplicate records in the dataset\n")
Exploratory Data Analysis (EDA) before Dimensionality Reduction using PCA¶
5 point summary of numerical attributes¶
In [18]:
vehicle_df.describe().T
Out[18]:
Outliers analysis of numerical columns¶
Visualizing Outliers in dataset using boxplot before replacing the outliers with mean¶
In [19]:
#Visualizing Outliers in dataset using boxplot before replacing the outliers with mean of columns
print('\n\t\tBoxplot to check the presence of outliers in numeric columns before replacement with mean')
print('\t\t===========================================================================================\n')
fig, ax = plt.subplots(6,3,figsize=(20, 25))
for col,subplot in zip(vehicle_df.drop('class', axis=1).columns,ax.flatten()) :
sns.boxplot(x=vehicle_df[[col]], width=0.8, color='orange', ax=subplot)
subplot.set_xlabel(col)
plt.show()
Observations on outlier analysis of numerical columns:¶
- Maximum number of Outliers (15) are present in scaled_radius_of_gyration.1 column
- pr.axis_aspect_ratio, max.length_aspect_ratio and skewness_about have 8, 13 and 12 outliers respectfully
- The remaining columns have 1,2 3 or no outliers
- Most of the columns are either right skewed or left skewed
- We can identifiy the outlier values using IQR and Quantiles method amd replace them with mean values
Identifying the Outliers using IQR and Quantiles and replacing them with mean¶
In [20]:
#Identifying Outliers in Numeric columns using IQR (Inter Quartile Range) and Q1 (25% Quantile), Q3(75% Quantile).
def identify_outliers(col):
q1 = vehicle_df[col].quantile(0.25)
q3 = vehicle_df[col].quantile(0.75)
iqr = q3 - q1
lower_limit = q1 - 1.5*iqr
upper_limit = q3 + 1.5*iqr
return(col, q1, q3, iqr, lower_limit, upper_limit)
In [21]:
#Checking for Outliers and identifying them by calling identify_outliers() function.
#observations below Q1- 1.5*IQR, or those above Q3 + 1.5*IQR are defined as outliers.
#Replace the outliers with mean of the column
for col in vehicle_df.drop('class', axis=1).columns :
col, q1, q3, iqr, lower_limit, upper_limit = identify_outliers(col)
print("\nColumn name : {}\n Q1 = {} \n Q3 = {}\n IQR = {}".format(col, q1, q3, iqr))
print(" Lower limit = {}\n Upper limit = {}\n".format(lower_limit, upper_limit))
outlier_count = len(vehicle_df.loc[(vehicle_df[col] < lower_limit) | (vehicle_df[col] > upper_limit)])
if outlier_count != 0 :
print(outlier_count, "OUTLIERS ARE PRESENT in {} column.".format(col))
print("Outlier datapoints in {} column are:".format(col))
print(np.array(vehicle_df.loc[(vehicle_df[col] < lower_limit) | (vehicle_df[col] > upper_limit)][col]))
print("Replacing Outliers with mean of the column {}...".format(col))
vehicle_df.loc[(vehicle_df[col] < lower_limit) | (vehicle_df[col] > upper_limit), col] = np.nan
vehicle_df[col].fillna(round(vehicle_df[col].mean()), inplace=True)
print('...Outliers are replaced with mean')
else:
print("OUTLIERS ARE NOT PRESENT in {} column\n".format(col))
Visualizing Outliers in dataset using boxplot after replacing the outliers with mean¶
In [22]:
#Visualizing Outliers in dataset using boxplot after replacing the outliers with mean of the columns
print('\n\t\tBoxplot to check the presence of outliers in numeric columns after replacement with mean')
print('\t\t==========================================================================================\n')
fig, ax = plt.subplots(6,3,figsize=(20, 25))
for col,subplot in zip(vehicle_df.drop('class', axis=1).columns,ax.flatten()) :
sns.boxplot(x=vehicle_df[[col]], width=0.8, color='orange', ax=subplot)
subplot.set_xlabel(col)
plt.show()
Observation¶
- After replacing the outlier values in the dataset with mean of the feature columns, the Boxplots do not show any outliers in the datset.
Variance in numerical columns¶
In [23]:
vehicle_df.var()
Out[23]:
Visualizing variance of numerical columns through lineplot¶
In [24]:
plt.figure(figsize=(10,5))
plt.xticks(rotation = 70, fontsize=12)
plt.yticks(fontsize=12)
plt.plot(vehicle_df.drop('class', axis=1).var(), color='green', marker='s',mec='black',linewidth=1, markersize=2)
plt.yscale('log')
plt.show()
Observations on variance of numerical columns¶
- The above line plot shows the variance values for all the numerical feature columns
- Variance in all the numerical columns vary exponentially
- Variance in max.length_aspect_ratio and pr.axis_rectangularity columns is very less with values 4.3 and 6.7
- Variance in scaled_variance.1 column is very high and in scale of 10^4
- Variance in columns radius_ratio, scatter_ratio, scaled_variance, scaled_radius_of_gyration.1 is in scale of 10^3
- Variance in distance_circularity and max.length_rectangularity in the order of 10^2 and remaining columns have variance between 10 and 100
- A high variance indicates that the data points are more spread out around the mean, ie the spread is more and a low variance indicates that the data points are more close to the mean, ie the spread is less.
- With the column variances varying exponentially, it is suggested to scale the column data using any standadization method for model building.
Univariate Analysis¶
Visualizing Distribution of numerical columns through distplots¶
In [25]:
fig, ax = plt.subplots(6,3,figsize=(20, 25))
for col,subplot in zip(vehicle_df.drop('class', axis=1).columns,ax.flatten()) :
ax =sns.distplot(vehicle_df[col], ax=subplot, hist_kws={'color':'g','alpha':1}, kde_kws={'color':'black', 'lw':2})
Observations on univariate analysis of numerical columns:¶
- Distplots for all the features show more than one Gaussian curve.So, there should be atleast two good clusters in the given dataset
- The 7 features compactness, distance_circularity, max.length_aspect_ratio, elongatedness, skewness_about, skewness_about.2, hollows_ratio show that two clusters exist and clearly distinguish the two clusters
- Th remainuing 10 features circularity, radius_ratio, scatter_ratio, pr.axis_rectangularity, max.length_rectangularity, scaled_variance, scaled_variance.1, scaled_radius_of_gyration, scaled_radius_of_gyration.1, skewness_about.1, show three clusters, but the third cluster is very small.
- With this evidence, we can say that two good clusters exist in the dataset.
- circularity is the only feature which shows only one gausian curve and is approximately normal.
Target column distribution¶
In [26]:
# The Target column is 'class'.
# Value counts and distribution of Target column
In [27]:
vehicle_df.groupby(by='class').count()
Out[27]:
In [28]:
sns.countplot(vehicle_df['class'], palette = 'plasma')
plt.show()
Observations on value counts of Target column:¶
- The car class has the highest count of 429 which is 51% of the data
- The bus class has a count of 218 which is 26% of the data
- The remaining 23% is van class which has count of 199
Bivariate Analysis¶
In [29]:
sns.pairplot(vars=list(vehicle_df.drop('class', axis=1).columns),hue='class',data=vehicle_df)
plt.show()
In [30]:
vehicle_df.columns
Out[30]:
Observations on bivariate analysis using pairplot:¶
- The ten features - compactness, circularity, distance_circularity, radius_ratio, scatter_ratio, pr.axis_rectangularity, max.length_rectangularity, scaled_variance, scaled_variance.1 and scaled_radius_of_gyration have good linear relationship among them and are positively correlated
- These ten features should be considered for building a model
- The feature elongatedness has a negative correlation with above ten features and should be considered for building a model
- The seven features pr.axis_aspect_ratio, max.length_aspect_ratio, scaled_radius_of_gyration.1, skewness_about, skewness_about.1, skewness_about.2, hollows_ratio are not correlated with any of other features as their scatter plots with the other features do give any inference
- These seven features need not be considered for building a model
- The two features scaled_radius_of_gyration, scaled_radius_of_gyration.1 are positively correlated among them but do not show linear relation with any of the other features
- The two features skewness_about.2, hollows_ratio are positively correlated among them but do not show linear relation with any of the other features
- The two features skewness_about, skewness_about.1 are not related among them and are also not related with any of the other features
- The KDE plots for all the features show overlapping gaussian curves, which shows that the three classes canno be classified easily.
The KDE plots show multiple gaussian curves for each classs and significantly show that two good clusters exist in the dataset
From the pairplot analysis we can conclude that 11 features are of importance and have to be part of the analysis.These features are - compactness, circularity, distance_circularity, radius_ratio, scatter_ratio, pr.axis_rectangularity, max.length_rectangularity, scaled_variance, scaled_variance.1 and scaled_radius_of_gyration, elongatedness
- The remaining 7 features need not be considered for anaysis
Correlation between numerical columns¶
In [31]:
corr = vehicle_df.corr()
corr.style.background_gradient(cmap='cubehelix')
Out[31]:
Visualizing Correlation between numerical columns through Heat map¶
In [32]:
plt.figure(figsize=(12,12))
sns.heatmap(corr, vmax=1, square=True,annot=True,cmap='cubehelix')
plt.show()
Observations on Correlation between numerical columns:¶
- The feature elongatedness shows negative correlation values and so has strong negative correlation with all other features except scaled_radius_of_gyration.1, skewness_about,skewness_about.1, skewness_about.2, hollows_ratio
- The features pr.axis_aspect_ratio, scaled_radius_of_gyration.1, skewness_about,skewness_about.1, skewness_about.2, hollows_ratio have very low correlation values
- pr.axis_rectangularity, max.length_rectangularity, scaled_variance, scaled_variance.1 are the features having high correlation values with any other features except pr.axis_aspect_ratio, scaled_radius_of_gyration.1, skewness_about,skewness_about.1, skewness_about.2, hollows_ratio
- The features compactness, circularity, distance_circularity, radius_ratio also show good correlation values
- From the correlation analysis we can conclude that 11 features are of importance and have to be part of the analysis.These features are - compactness, circularity, distance_circularity, radius_ratio, scatter_ratio, pr.axis_rectangularity, max.length_rectangularity, scaled_variance, scaled_variance.1 and scaled_radius_of_gyration, elongatedness
- The remaining 7 features need not be considered for anaysis
Dimensionality Reduction using Principal Component Analysis (PCA)¶
Label Encoding class column with values 0,1,2 for van, car and bus¶
In [33]:
vehicle_df['class'].unique()
Out[33]:
In [34]:
#Use LabelEncoder to convert the class values to numeric
le = LabelEncoder()
le.fit(vehicle_df['class'])
Out[34]:
In [35]:
vehicle_df['class'] = le.transform(vehicle_df['class'])
In [36]:
le.classes_
Out[36]:
In [37]:
vehicle_df['class'].unique()
Out[37]:
Create the X(Feature-set) and Y(Target-set) sets for your Data.¶
In [38]:
X = vehicle_df.drop('class',axis=1)
y = vehicle_df['class']
In [39]:
print('Shape of Feture-set : ', X.shape)
print('Shape of Target-set : ', y.shape)
Split the data as train set and test set with a ratio of 70:30.¶
In [40]:
(X_train, X_test, y_train, y_test) = train_test_split(X, y, test_size=0.30, random_state=7)
In [41]:
print("Training Set Shape:\nFeatures : {0} Target : {1}\n".format(X_train.shape, y_train.shape))
print("Test Set Shape:\nFeatures : {0} Target : {1}".format(X_test.shape, y_test.shape))
Standardize the training dataset and test dataset¶
In [42]:
#Standardization using Standard Scaler class of sklearn.preprocessing module
#Training set scaled using Standard Scaler
scaler = StandardScaler().fit(X_train)
In [43]:
#Training set transformed to fit Standard Scaler
X_trainS = scaler.transform(X_train)
In [44]:
#Test set transformed to fit Standard Scaler
X_testS = scaler.transform(X_test)
In [45]:
print(X_trainS.mean(), X_trainS.std())
In [46]:
print(X_testS.mean(), X_testS.std())
Apply PCA on the Full Feature Set¶
Creating PCA featureset with all Possible Principle Components by giving n_components = None¶
In [47]:
#Creating all Possible Principle Components by giving n_components = None
#Use fit() method to fit the Model on X_TrainS
pca = PCA()
pca.fit(X_trainS)
Out[47]:
In [48]:
#Use transform() method on X_trainS, to transform and and return the principle components createdn for X_trainS
XtrainS_pca = pca.transform(X_trainS)
In [49]:
#Use transform() method on X_TestS, to transform and and return the principle components created for Xtest_S.
XtestS_pca = pca.transform(X_testS)
In [50]:
XtrainS_pca[0:3], XtestS_pca[0:3]
Out[50]:
In [51]:
#Number of Principal components created out of the PCA model when fit on the train set
pca.n_components_
Out[51]:
In [52]:
#The Principal components for all the features - no of Principal components X no of features
#pca.components_
In [53]:
#The variance explained by each of the Principal component
pca.explained_variance_
Out[53]:
In [54]:
#The percentage of variance explained by each of the Principal component
pca.explained_variance_ratio_
Out[54]:
In [55]:
#Sort the explained variance ratio in descending order to find which pc explains highest amount of variance and also
#to find the numer of pc's which explain 95% or more variance
explained_var_ratio = sorted(pca.explained_variance_ratio_, reverse=True)
explained_var_ratio
Out[55]:
In [56]:
#Find the principal components which explain more than 95% of variance and also find their count
total_variance = 0
pca_comp_list = []
for ele in explained_var_ratio:
total_variance = total_variance + ele
pca_comp_list.append(ele)
if total_variance >=0.95 :
print("explained varince =", total_variance)
break
#print(total_variance)
print("Prinicipal Components list is \n",pca_comp_list)
#print(sum(pca_comp_list))
In [57]:
print("Total number of principal components which cover more than 95% variance =", len(pca_comp_list))
print ("The total variance explained by the {} Features = {}".format( len(pca_comp_list),round(sum(pca_comp_list),2)))
In [58]:
# Elbow Method to find Number of Principal components which explain more than 95% of variance in the Feature Set
plt.figure(figsize=(8,5))
plt.plot(np.cumsum(pca.explained_variance_ratio_), marker='+', mec='r', ms=10)
plt.xlim(0,pca.explained_variance_ratio_.shape[0],1)
plt.xlabel('Number of components')
plt.ylabel('Cumulative explained variance')
plt.show()
Observations from PCA:¶
- It can be seen that first principal component explains 52.45% variance, the second principal component explains 16.65% variance in the dataset.
- Collectively 96.24% of the variance in the Features in the original dataset is explained by 7 Principal components
- So, instead of using all 18 Features of the original dataset for building the model, we can use only 7 of the Principal components obtained using PCA, which contain 96% of the information of all features in the original dataset, and explain 96% of the variance.
Creating PCA featureset with 7 Principle Components which explain 96% variance by giving n_components = 7¶
In [59]:
#Creating all Possible Principle Components by giving n_components = None
#Use fit() method to fit the Model on X_TrainS
pca_7comp = PCA(n_components = 7)
pca_7comp.fit(X_trainS)
Out[59]:
In [60]:
#Use transform() method on X_trainS, to transform and and return the principle components createdn for X_trainS
XtrainS_pca = pca_7comp.transform(X_trainS)
In [61]:
#Use transform() method on X_testS, to transform and and return the principle components createdn for X_testS
XtestS_pca = pca_7comp.transform(X_testS)
In [62]:
XtrainS_pca[0:3], XtestS_pca[0:3]
Out[62]:
In [63]:
#Number of Principal components created out of the new PCA model when fit on the train set
pca_7comp.n_components_
Out[63]:
In [64]:
#The Principal components for all the features - no of Principal components X no of features
#pca_7comp.components_
In [65]:
#The variance explained by each of the Principal component
pca_7comp.explained_variance_
Out[65]:
In [66]:
#The percentage of variance explained by each of the Principal component
pca_7comp.explained_variance_ratio_
Out[66]:
We will use the 7 Principal components obtained from the PCA model to build the model using SVM¶
Implementing Support Vector Machine (SVM) Classification model¶
In [67]:
#DataFrame to store model Performance metrics of SVM done before performing PCA and after performing PCA
compare_metrics_df = pd.DataFrame(index=('SVM WITHOUT HyperParams', 'SVM WITH HyperParams'),
columns=('Trainingset Accuracy', 'Testset Accuracy', 'Precision Score',
'Recall Score', 'F1 Score'))
In [68]:
compare_metrics_df.index.name = 'Classifier Name'
Implementing SVM algorithm on PCA Train and Test sets Without Hyperparameter Tuning¶
In [69]:
#Implementing SVM Classifier with default kernel as rbf
svm_clf = SVC(C=1.0, degree=3, gamma='scale', kernel='rbf', max_iter=-1, random_state=7)
svm_clf
Out[69]:
In [70]:
#Fit the model to the training set with Principal Component Features
svm_clf.fit(XtrainS_pca, y_train)
Out[70]:
In [71]:
# Predict classes using the built model
yhat_svm = svm_clf.predict(XtestS_pca)
In [72]:
# Model accuracy score using score() function on Training data set
compare_metrics_df.loc['SVM WITHOUT HyperParams','Trainingset Accuracy'] = round(svm_clf.score(XtrainS_pca, y_train), 2)
svm_clf.score(XtrainS_pca, y_train)
Out[72]:
In [73]:
# Model accuracy score using score() function on Test data set
compare_metrics_df.loc['SVM WITHOUT HyperParams','Testset Accuracy'] = round(svm_clf.score(XtestS_pca, y_test), 2)
svm_clf.score(XtestS_pca, y_test)
Out[73]:
Calculating Model Performance Metrics.¶
confusion matrix¶
In [74]:
confusion_matrix_svm = confusion_matrix(y_test, yhat_svm)
confusion_matrix(y_test, yhat_svm)
Out[74]:
accuracy-score¶
In [75]:
accuracy_score(y_test, yhat_svm)
Out[75]:
Precision score¶
In [76]:
compare_metrics_df.loc['SVM WITHOUT HyperParams','Precision Score'] = round(precision_score(y_test, yhat_svm, average='weighted'), 2)
precision_score(y_test, yhat_svm, average='weighted')
Out[76]:
Recall score¶
In [77]:
compare_metrics_df.loc['SVM WITHOUT HyperParams','Recall Score'] = round(recall_score(y_test, yhat_svm, average='weighted'), 2)
recall_score(y_test, yhat_svm, average='weighted')
Out[77]:
F1-Score¶
In [78]:
compare_metrics_df.loc['SVM WITHOUT HyperParams','F1 Score'] = round(f1_score(y_test, yhat_svm, average='weighted'), 2)
f1_score(y_test, yhat_svm, average='weighted')
Out[78]:
Classification report¶
In [79]:
print(classification_report(y_test, yhat_svm))
Implementing SVM algorithm on PCA Train and Test sets With Hyperparameter Tuning¶
In [80]:
# dist of Hyper Parameters which are passed to GridSearchCV method to find the best hyper parameters
hyper_params = {'C':[0.01,0.05,0.1,0.5,1.0,5.0,10.0], 'gamma':('auto', 'scale'), 'kernel':('linear','poly','rbf'),
'random_state':[7]}
In [81]:
#create an instance of SM class and pass it as estimator to GridSearchCV along with dict of hyper parameters
#use 5 folds of the data using cv=5 to find the best accuracy along models built
svm_clf_reg = SVC()
grid_search_cv = GridSearchCV(estimator=svm_clf_reg, param_grid=hyper_params, cv=5, iid=False)
In [82]:
#Fit the GridSearchCV model to obtain the dfferent SVM models with different hyper parameters for 5 fold splits
grid_search_cv.fit(XtrainS_pca, y_train)
Out[82]:
In [83]:
# Get the list of metrics output by GridSearchCV model
sorted(grid_search_cv.cv_results_.keys())
Out[83]:
In [84]:
# Get all the hyper parameters combinations output by model
grid_search_cv.cv_results_['params']
Out[84]:
In [85]:
#Best Hyper parameters output by the model
grid_search_cv.best_params_
Out[85]:
In [86]:
#Best Estimator output by the model with the best hyper parameters
grid_search_cv.best_estimator_
Out[86]:
In [87]:
#Accuracy score for each split
for i in ['split0_test_score', 'split1_test_score', 'split2_test_score', 'split3_test_score', 'split4_test_score']:
print(grid_search_cv.cv_results_[i])
In [88]:
# Mean Accuracy Score of each split for all hyper Parameters
grid_search_cv.cv_results_['mean_test_score']
Out[88]:
In [89]:
# Std Accuracy Score of each split for all hyper Parameters
grid_search_cv.cv_results_['std_test_score']
Out[89]:
The Best Hyper Parameters are {'C': 5.0, 'gamma': 'scale', 'kernel': 'rbf', 'random_state': 7}¶
In [90]:
#Implementing SVM Classifier using best hyper parameters obtained by using GridSearchCV and Cross validation
svc_best = SVC(C=5.0, cache_size=200, class_weight=None, coef0=0.0,
decision_function_shape='ovr', degree=3, gamma='scale', kernel='rbf',
max_iter=-1, probability=False, random_state=7, shrinking=True, tol=0.001,
verbose=False)
In [91]:
#Fit the model with best hyper parameters to the training set with Principal Component Features
svc_best.fit(XtrainS_pca, y_train)
Out[91]:
In [92]:
# Predict classes using the built model
yhat_svm_best = svc_best.predict(XtestS_pca)
In [93]:
# Model accuracy score using score() function on Training data set
compare_metrics_df.loc['SVM WITH HyperParams','Trainingset Accuracy'] = round(svc_best.score(XtrainS_pca, y_train), 2)
svc_best.score(XtrainS_pca, y_train)
Out[93]:
In [94]:
# Model accuracy score using score() function on Test data set
compare_metrics_df.loc['SVM WITH HyperParams','Testset Accuracy'] = round(svc_best.score(XtestS_pca, y_test), 2)
svc_best.score(XtestS_pca, y_test)
Out[94]:
Calculating Model Performance Metrics.¶
confusion matrix¶
In [95]:
confusion_matrix_svm = confusion_matrix(y_test, yhat_svm_best)
confusion_matrix(y_test, yhat_svm_best)
Out[95]:
accuracy-score¶
In [96]:
accuracy_score(y_test, yhat_svm_best)
Out[96]:
Precision score¶
In [97]:
compare_metrics_df.loc['SVM WITH HyperParams','Precision Score'] = round(precision_score(y_test, yhat_svm_best, average='weighted'), 2)
precision_score(y_test, yhat_svm_best, average='weighted')
Out[97]:
Recall score¶
In [98]:
compare_metrics_df.loc['SVM WITH HyperParams','Recall Score'] = round(recall_score(y_test, yhat_svm_best, average='weighted'), 2)
recall_score(y_test, yhat_svm_best, average='weighted')
Out[98]:
F1-Score¶
In [99]:
compare_metrics_df.loc['SVM WITH HyperParams','F1 Score'] = round(f1_score(y_test, yhat_svm_best, average='weighted'), 2)
f1_score(y_test, yhat_svm_best, average='weighted')
Out[99]:
Classification report¶
In [100]:
print(classification_report(y_test, yhat_svm_best))
Comparision of Metrics obtained by implementing SVM Without Hyper Parameters and With Hyper Parameters¶
In [101]:
compare_metrics_df
Out[101]: